// 使用示例：新的hash计算功能
// 这个文件展示了如何在你的应用中使用新的hash计算功能

import { calculateFileHash, calculateFileHashWithProgress } from '../utils/hashUtils';

/**
 * 示例1: 基本hash计算
 */
export async function basicHashExample(): Promise<void> {
  console.log('=== 基本Hash计算示例 ===');
  
  // 创建一个测试文件
  const file = new File(['Hello, World!'], 'test.txt', { type: 'text/plain' });
  
  try {
    // 计算hash值
    const hash = await calculateFileHash(file);
    console.log(`文件hash值: ${hash}`);
  } catch (error) {
    console.error('Hash计算失败:', error);
  }
}

/**
 * 示例2: 带进度回调的hash计算
 */
export async function progressHashExample(): Promise<void> {
  console.log('=== 带进度回调的Hash计算示例 ===');
  
  // 创建一个较大的测试文件 (1MB)
  const largeContent = new Array(1024 * 1024).fill('A').join('');
  const largeFile = new File([largeContent], 'large.txt', { type: 'text/plain' });
  
  try {
    const hash = await calculateFileHashWithProgress(
      largeFile,
      (progress) => {
        console.log(`Hash计算进度: ${progress.toFixed(1)}%`);
      }
    );
    console.log(`大文件hash值: ${hash}`);
  } catch (error) {
    console.error('Hash计算失败:', error);
  }
}

/**
 * 示例3: 自定义选项的hash计算
 */
export async function customOptionsHashExample(): Promise<void> {
  console.log('=== 自定义选项的Hash计算示例 ===');
  
  const file = new File(['Test content'], 'test.txt', { type: 'text/plain' });
  
  try {
    // 强制使用Worker，即使文件很小
    const hash1 = await calculateFileHash(file, {
      useWorker: true,
      chunkSize: 512 * 1024, // 512KB分片
      onProgress: (progress) => {
        console.log(`Worker计算进度: ${progress.toFixed(1)}%`);
      }
    });
    console.log(`Worker计算hash: ${hash1}`);
    
    // 强制使用主线程
    const hash2 = await calculateFileHash(file, {
      useWorker: false,
      onProgress: (progress) => {
        console.log(`主线程计算进度: ${progress.toFixed(1)}%`);
      }
    });
    console.log(`主线程计算hash: ${hash2}`);
    
    // 验证两个hash值相同
    console.log(`Hash值相同: ${hash1 === hash2}`);
  } catch (error) {
    console.error('Hash计算失败:', error);
  }
}

/**
 * 示例4: 在文件上传中使用
 */
export async function fileUploadHashExample(file: File): Promise<string> {
  console.log('=== 文件上传Hash计算示例 ===');
  
  try {
    console.log(`开始计算文件hash: ${file.name} (${(file.size / 1024 / 1024).toFixed(2)}MB)`);
    
    const fileHash = await calculateFileHash(file, {
      useWorker: file.size > 1024 * 1024, // 大于1MB使用Worker
      chunkSize: 1024 * 1024, // 1MB分片
      onProgress: (progress) => {
        console.log(`文件 ${file.name} hash计算进度: ${progress.toFixed(1)}%`);
      }
    });
    
    console.log(`文件hash计算完成: ${fileHash}`);
    return fileHash;
  } catch (error) {
    console.error('文件hash计算失败:', error);
    throw error;
  }
}

/**
 * 示例5: 错误处理
 */
export async function errorHandlingExample(): Promise<void> {
  console.log('=== 错误处理示例 ===');
  
  try {
    // 尝试计算一个无效的文件
    const invalidFile = new File([], 'empty.txt', { type: 'text/plain' });
    const hash = await calculateFileHash(invalidFile);
    console.log(`空文件hash: ${hash}`);
  } catch (error) {
    console.error('预期的错误:', error);
  }
}

/**
 * 运行所有示例
 */
export async function runAllExamples(): Promise<void> {
  console.log('🚀 开始运行Hash计算示例...\n');
  
  try {
    await basicHashExample();
    console.log('\n');
    
    await progressHashExample();
    console.log('\n');
    
    await customOptionsHashExample();
    console.log('\n');
    
    // 创建一个测试文件用于上传示例
    const testFile = new File(['Test upload content'], 'upload.txt', { type: 'text/plain' });
    await fileUploadHashExample(testFile);
    console.log('\n');
    
    await errorHandlingExample();
    console.log('\n');
    
    console.log('✅ 所有示例运行完成!');
  } catch (error) {
    console.error('❌ 示例运行失败:', error);
  }
}

// 导出所有示例函数
export const hashExamples = {
  basicHashExample,
  progressHashExample,
  customOptionsHashExample,
  fileUploadHashExample,
  errorHandlingExample,
  runAllExamples
};
